package lambdademo;


import java.util.Comparator;
import java.util.PriorityQueue;

@FunctionalInterface
//函数式接口 只能有一个函数(@FunctionalInterface修饰)
interface NoParameterNoReturn {
//    只能有一个方法
    void test();
//    void test2();  如果添加这行代码  @FunctionalInterface会报红
}
interface NoParameterNoReturn2 {
    void test();
    default void test2() {
        System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
    }
}




//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn3 {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}










public class TestDemo {
    public static void main1(String[] args) {
//        接口实现类 重写test方法
        NoParameterNoReturn parameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("重写方法!!!");
            }
        };
        parameterNoReturn.test();//重写方法!!!
    }



//    简化方法
//    无返回值无参数
    public static void main2(String[] args) {
//                                              Lambda表达式(使代码量减少了)
        NoParameterNoReturn parameterNoReturn = ()-> System.out.println("重写test方法!!!");
        parameterNoReturn.test();//重写test方法!!!
    }


//    无返回值一个参数
    public static void main3(String[] args) {
        OneParameterNoReturn oneParameterNoReturn = (a)->{System.out.println(a);};
        oneParameterNoReturn.test(10);//10

//        优化   一个参数可以省略()  一条语句可以省略{}
        OneParameterNoReturn oneParameterNoReturn2 = a-> System.out.println(a);
        oneParameterNoReturn2.test(10);//10
    }

//    无返回值多个参数
    public static void main4(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = (int a,int b)-> {System.out.println(a+" "+b);};
        moreParameterNoReturn.test(10,20);//10 20

//        简写 参数类型一样可以省略  箭头后是一条语句{}可以省略
        MoreParameterNoReturn moreParameterNoReturn2 = (a,b)-> System.out.println(a+b);
        moreParameterNoReturn2.test(10,20);//30
    }


//    有返回值无参数
    public static void main5(String[] args) {
        NoParameterReturn noParameterReturn = ()->{return 10;};
        int ret = noParameterReturn.test();
        System.out.println(ret);//10

//        简写
        NoParameterReturn noParameterReturn2 = ()->20;
        int ret2 = noParameterReturn2.test();
        System.out.println(ret2);//20
    }



//    有返回值有一个参数
    public static void main6(String[] args) {
        OneParameterReturn oneParameterReturn = a->a+11;
        int ret = oneParameterReturn.test(10);
        System.out.println(ret);//21
    }


//    有返回值多个参数
    public static void main7(String[] args) {
        MoreParameterReturn moreParameterReturn = (a,b)->a+b;
        int ret = moreParameterReturn.test(12,18);
        System.out.println(ret);//30
    }


//    之前写的代码就可以这样简化了
    public static void main8(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(3, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

        PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>(3, (o1, o2) -> o1 - o2);
    }
}
